// 请求参数验证中间件
const expressModule = require('../zh/后端/Express');

/**
 * 创建验证中间件 - 根据规则验证请求参数
 * @param {Object} 验证规则 - 包含各种验证规则的对象
 * @returns {Function} 中间件函数
 */
function 创建验证中间件(验证规则) {
  return function(请求, 响应, 下一个) {
    try {
      const 错误信息 = [];
      
      // 验证请求参数
      if (验证规则.params) {
        Object.entries(验证规则.params).forEach(([参数名, 规则]) => {
          const 参数值 = 请求.params[参数名];
          const 验证结果 = 验证字段(参数名, 参数值, 规则);
          
          if (!验证结果.valid) {
            错误信息.push(验证结果.message);
          }
        });
      }
      
      // 验证查询参数
      if (验证规则.query) {
        Object.entries(验证规则.query).forEach(([参数名, 规则]) => {
          const 参数值 = 请求.query[参数名];
          const 验证结果 = 验证字段(参数名, 参数值, 规则);
          
          if (!验证结果.valid) {
            错误信息.push(验证结果.message);
          }
        });
      }
      
      // 验证请求体
      if (验证规则.body) {
        Object.entries(验证规则.body).forEach(([参数名, 规则]) => {
          const 参数值 = 请求.body[参数名];
          const 验证结果 = 验证字段(参数名, 参数值, 规则);
          
          if (!验证结果.valid) {
            错误信息.push(验证结果.message);
          }
        });
      }
      
      // 如果有验证错误，返回错误响应
      if (错误信息.length > 0) {
        expressModule.设置状态码(响应, 400);
        return expressModule.发送JSON(响应, {
          success: false,
          message: '请求参数验证失败',
          errors: 错误信息,
          code: 'VALIDATION_ERROR'
        });
      }
      
      // 验证通过，继续处理请求
      下一个();
    } catch (错误) {
      console.error('验证中间件错误:', 错误);
      expressModule.设置状态码(响应, 500);
      expressModule.发送JSON(响应, {
        success: false,
        message: '验证过程中发生错误',
        code: 'VALIDATION_PROCESS_ERROR'
      });
    }
  };
}

/**
 * 验证单个字段
 * @param {string} 字段名 - 字段名称
 * @param {*} 字段值 - 字段值
 * @param {Object} 规则 - 验证规则
 * @returns {Object} 验证结果 {valid: boolean, message?: string}
 */
function 验证字段(字段名, 字段值, 规则) {
  // 检查是否必填
  if (规则.required && (字段值 === undefined || 字段值 === null || 字段值 === '')) {
    return {
      valid: false,
      message: `字段 '${字段名}' 是必填项`
    };
  }
  
  // 如果字段值为空且不是必填项，则跳过后续验证
  if (!规则.required && (字段值 === undefined || 字段值 === null)) {
    return { valid: true };
  }
  
  // 检查类型
  if (规则.type && typeof 字段值 !== 规则.type) {
    return {
      valid: false,
      message: `字段 '${字段名}' 必须是 ${规则.type} 类型`
    };
  }
  
  // 检查字符串长度
  if (规则.type === 'string') {
    if (规则.minLength && 字段值.length < 规则.minLength) {
      return {
        valid: false,
        message: `字段 '${字段名}' 长度不能少于 ${规则.minLength} 个字符`
      };
    }
    
    if (规则.maxLength && 字段值.length > 规则.maxLength) {
      return {
        valid: false,
        message: `字段 '${字段名}' 长度不能超过 ${规则.maxLength} 个字符`
      };
    }
    
    // 检查正则表达式匹配
    if (规则.pattern && !规则.pattern.test(字段值)) {
      return {
        valid: false,
        message: `字段 '${字段名}' 格式不正确`
      };
    }
  }
  
  // 检查数字范围
  if ((规则.type === 'number' || !isNaN(字段值)) && !isNaN(Number(字段值))) {
    const 数值 = Number(字段值);
    
    if (规则.min !== undefined && 数值 < 规则.min) {
      return {
        valid: false,
        message: `字段 '${字段名}' 不能小于 ${规则.min}`
      };
    }
    
    if (规则.max !== undefined && 数值 > 规则.max) {
      return {
        valid: false,
        message: `字段 '${字段名}' 不能大于 ${规则.max}`
      };
    }
  }
  
  // 检查枚举值
  if (规则.enum && !规则.enum.includes(字段值)) {
    return {
      valid: false,
      message: `字段 '${字段名}' 必须是以下值之一: ${规则.enum.join(', ')}`
    };
  }
  
  // 检查自定义验证函数
  if (规则.validator && typeof 规则.validator === 'function') {
    const 验证结果 = 规则.validator(字段值);
    
    if (!验证结果.valid) {
      return {
        valid: false,
        message: 验证结果.message || `字段 '${字段名}' 验证失败`
      };
    }
  }
  
  // 所有验证通过
  return { valid: true };
}

// 预定义的常用验证规则
const 常用规则 = {
  // 用户名验证
  用户名: {
    required: true,
    type: 'string',
    minLength: 3,
    maxLength: 50,
    pattern: /^[a-zA-Z0-9_\u4e00-\u9fa5]+$/
  },
  
  // 密码验证
  密码: {
    required: true,
    type: 'string',
    minLength: 6
  },
  
  // 邮箱验证
  邮箱: {
    required: true,
    type: 'string',
    pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/
  },
  
  // ID验证
  ID: {
    required: true,
    type: 'string',
    pattern: /^[a-zA-Z0-9]+$/
  },
  
  // 页码验证
  页码: {
    required: false,
    type: 'number',
    min: 1,
    validator: (value) => {
      return {
        valid: Number.isInteger(Number(value)),
        message: '页码必须是整数'
      };
    }
  },
  
  // 每页数量验证
  每页数量: {
    required: false,
    type: 'number',
    min: 1,
    max: 100,
    validator: (value) => {
      return {
        valid: Number.isInteger(Number(value)),
        message: '每页数量必须是整数'
      };
    }
  }
};

module.exports = {
  创建验证中间件,
  常用规则
};